home *** CD-ROM | disk | FTP | other *** search
/ Ian & Stuart's Australian Mac: Not for Sale / Another.not.for.sale (Australia).iso / fade into you / getting there / Apps / MOO-1.7.6.src / src / objects.c < prev    next >
Text File  |  1994-11-02  |  15KB  |  612 lines
  1. /******************************************************************************
  2.   Copyright (c) 1992 Xerox Corporation.  All rights reserved.
  3.   Portions of this code were written by Stephen White, aka ghond.
  4.   Use and copying of this software and preparation of derivative works based
  5.   upon this software are permitted.  Any distribution of this software or
  6.   derivative works must comply with all applicable United States export
  7.   control laws.  This software is made available AS IS, and Xerox Corporation
  8.   makes no warranty about the software, its performance or its conformity to
  9.   any specification.  Any person obtaining a copy of this software is requested
  10.   to send their name and post office or electronic mail address to:
  11.     Pavel Curtis
  12.     Xerox PARC
  13.     3333 Coyote Hill Rd.
  14.     Palo Alto, CA 94304
  15.     Pavel@Xerox.Com
  16.  *****************************************************************************/
  17.  
  18. #include "db.h"
  19. #include "exceptions.h"
  20. #include "execute.h"
  21. #include "functions.h"
  22. #include "list.h"
  23. #include "quota.h"
  24. #include "server.h"
  25. #include "storage.h"
  26. #include "structures.h"
  27. #include "utils.h"
  28.  
  29.  
  30. struct bf_move_data {
  31.   Objid what, where;
  32. };
  33.  
  34. static Var
  35. make_arglist(Objid what)
  36. {
  37.     Var        r;
  38.  
  39.     r = new_list(1);
  40.     r.v.list[1].type = TYPE_OBJ;
  41.     r.v.list[1].v.obj = what;
  42.  
  43.     return r;
  44. }
  45.  
  46. static package
  47. do_move(Var arglist, Byte next, struct bf_move_data *data, Objid progr)
  48. {
  49.     Objid        what = data->what, where = data->where;
  50.     Objid        oid, oldloc;
  51.     int            accepts;
  52.     Var            args;
  53.     enum error        e;
  54.     
  55.     switch (next) {
  56.       case 1:            /* Check validity and decide `accepts' */
  57.     if (!valid(what)  || (!valid(where)  &&  where != NOTHING))
  58.         return make_error_pack(E_INVARG);
  59.     else if (obj_owner(what) != progr  &&  !is_wizard(progr))
  60.         return make_error_pack(E_PERM);
  61.     else if (where == NOTHING)
  62.         accepts = 1;
  63.     else {
  64.         args = make_arglist(what);
  65.         e = call_verb(where, "accept", args, 0);
  66.         /* e will not be E_INVIND or E_TYPE */
  67.         
  68.         if (e == E_NONE) 
  69.         return make_call_pack(2, data);
  70.         else {
  71.         free_var(args);
  72.         if (e == E_MAXREC)
  73.             return make_error_pack(e);
  74.         else /* (e == E_VERBNF) */
  75.             accepts = 0;
  76.         }
  77.     }
  78.     goto accepts_decided;
  79.  
  80.       case 2:            /* Returned from `accepts' call */
  81.     accepts = is_true(arglist);
  82.  
  83.       accepts_decided:
  84.     if (!is_wizard(progr) && accepts == 0) 
  85.         return make_error_pack(E_NACC);
  86.     
  87.     if (!valid(what)
  88.         ||  (where != NOTHING  &&  !valid(where))
  89.         ||  obj_location(what) == where)
  90.         return no_var_pack();
  91.     
  92.     /* Check to see that we're not trying to violate the hierarchy */
  93.     for (oid = where; oid != NOTHING; oid = obj_location(oid))
  94.         if (oid == what)
  95.         return make_error_pack(E_RECMOVE);
  96.     
  97.     /* Remove thing from its old location, if it has one */
  98.     oldloc = obj_location(what);
  99.     if (valid(oldloc))
  100.         remove_content(oldloc, what);
  101.     
  102.     /* Move it to the new location, if any */
  103.     if (valid(where))
  104.         add_content(where, what);
  105.     set_obj_location(what, where);
  106.     
  107.     args = make_arglist(what);
  108.     e = call_verb(oldloc, "exitfunc", args, 0);
  109.     /* e != E_TYPE */
  110.     
  111.     if (e == E_NONE) 
  112.         return make_call_pack(3, data);
  113.     else {
  114.         free_var(args);
  115.         if (e == E_MAXREC) 
  116.         return make_error_pack(e);
  117.     }
  118.     /* e == E_INVIND or E_VERBNF, in both cases fall through */
  119.  
  120.       case 3:            /* Returned from exitfunc call */
  121.     if (valid(where) && valid(what)
  122.         && obj_location(what) == where) {
  123.         args = make_arglist(what);
  124.         e = call_verb(where, "enterfunc", args, 0);
  125.         /* e != E_TYPE or E_INVIND */
  126.         
  127.         if (e == E_NONE) 
  128.         return make_call_pack(4, data);
  129.         else {
  130.         free_var(args);
  131.         if (e == E_MAXREC) 
  132.             return make_error_pack(e);
  133.         /* else e == E_VERBNF, fall through */
  134.         }
  135.     }
  136.  
  137.       case 4:            /* Returned from enterfunc call */
  138.     return no_var_pack();
  139.  
  140.       default:
  141.     panic("Unknown PC in DO_MOVE");
  142.     return no_var_pack();    /* Dead code to eliminate compiler warning */
  143.     }
  144. }
  145.  
  146. /* external */
  147.  
  148. static package
  149. bf_toobj(Var arglist, Byte next, void *vdata, Objid progr)
  150. {
  151.     Var r; 
  152.     enum error e;
  153.     
  154.     r.type = TYPE_OBJ;
  155.     e = become_number(arglist.v.list[1], &(r.v.obj), 0);
  156.     
  157.     free_var(arglist);
  158.     if (e != E_NONE)
  159.     return make_error_pack(e);
  160.     
  161.     return make_var_pack(r);
  162. }
  163.  
  164. static package
  165. bf_typeof(Var arglist, Byte next, void *vdata, Objid progr)
  166. {
  167.     Var r;
  168.     r.type = TYPE_NUM;
  169.     r.v.num = (int) arglist.v.list[1].type;
  170.     free_var(arglist);
  171.     return make_var_pack(r);
  172. }
  173.  
  174. static package
  175. bf_create(Var arglist, Byte next, void *vdata, Objid progr)
  176. { /* (parent [, owner]) */
  177.     Objid *data = vdata;
  178.     Var r;  
  179.     
  180.     if (next == 1) { 
  181.     Objid parent, owner;
  182.     
  183.     parent = arglist.v.list[1].v.obj;
  184.     owner = (arglist.v.list[0].v.num == 2
  185.          ? arglist.v.list[2].v.obj
  186.          : progr);
  187.     free_var(arglist);
  188.     
  189.     if (!valid(parent)
  190.         || !Obj_perm(progr, parent, FLAG_FERTILE)
  191.         || (owner != progr && !is_wizard(progr))) 
  192.         return make_error_pack(E_PERM);
  193.  
  194.     r.type = TYPE_OBJ;
  195.     r.v.obj = create_object("", parent, owner);
  196.     
  197.     if (r.v.obj == NOTHING)
  198.         return make_error_pack(E_QUOTA);
  199.     else {
  200.         enum error e;
  201.         Var    args;
  202.         
  203.         data = alloc_data(sizeof(*data));
  204.         *data = r.v.obj;
  205.         args = new_list(0);
  206.         e = call_verb(r.v.obj, "initialize", args, 0);
  207.         /* e will not be E_INVIND or E_TYPE */
  208.         
  209.         if (e == E_NONE)
  210.         return make_call_pack(2, data);
  211.         
  212.         free_data(data);
  213.         free_var(args);
  214.         
  215.         if (e == E_MAXREC) 
  216.         return make_error_pack(e);
  217.         else /* (e == E_VERBNF) do nothing */
  218.         return make_var_pack(r);
  219.     }
  220.     } else { /* next == 2, returns from initialize verb_call */
  221.     r.type = TYPE_OBJ;
  222.     r.v.obj = *data;
  223.     free_data(data);
  224.     return make_var_pack(r);
  225.     }      
  226. }
  227.  
  228. static void
  229. bf_create_write(void *vdata)
  230. {
  231.     db_printf("bf_create data: oid = %d\n", *((Objid *) vdata));
  232. }
  233.  
  234. static void *
  235. bf_create_read(FILE *f)
  236. {
  237.     Objid *data = alloc_data(sizeof(Objid));
  238.     
  239.     if (fscanf(f, "bf_create data: oid = %d\n", data) == 1)
  240.     return data;
  241.     else
  242.     return 0;
  243. }
  244.  
  245. static package
  246. bf_chparent(Var arglist, Byte next, void *vdata, Objid progr)
  247. { /* (object, new_parent) */
  248.     Var r;
  249.  
  250.     r = change_parent(arglist.v.list[1].v.obj, arglist.v.list[2].v.obj, progr);
  251.     free_var(arglist);
  252.     if (r.type == TYPE_ERR) 
  253.     return make_error_pack(r.v.err);
  254.     else 
  255.     return no_var_pack();
  256. }
  257.  
  258. static package
  259. bf_valid(Var arglist, Byte next, void *vdata, Objid progr)
  260. { /* (object) */
  261.     Var r;
  262.     
  263.     r.type = TYPE_NUM;
  264.     r.v.num = valid(arglist.v.list[1].v.obj);
  265.     free_var(arglist);
  266.     return make_var_pack(r);
  267. }
  268.  
  269. static package
  270. bf_parent(Var arglist, Byte next, void *vdata, Objid progr)
  271. { /* (object) */
  272.     Var r;
  273.     Objid obj = arglist.v.list[1].v.obj;
  274.     
  275.     free_var(arglist);
  276.     
  277.     if (!valid(obj)) 
  278.     return make_error_pack(E_INVARG);
  279.     else {
  280.     r.type = TYPE_OBJ;
  281.     r.v.obj = obj_parent(obj);
  282.     return make_var_pack(r);
  283.     }
  284. }
  285.  
  286. static package
  287. bf_children(Var arglist, Byte next, void *vdata, Objid progr)
  288. { /* (object) */
  289.     Var r;
  290.     Objid obj = arglist.v.list[1].v.obj;
  291.     
  292.     free_var(arglist);
  293.     
  294.     if (!valid(obj)) 
  295.     return make_error_pack(E_INVARG);
  296.     else {
  297.     Var        child;
  298.     Objid        oid;
  299.     int        i, count = 0;
  300.  
  301.     for (oid = obj_child(obj);
  302.          oid != NOTHING;
  303.          oid = obj_sibling(oid))
  304.         count++;
  305.     r = new_list(count);
  306.     child.type = TYPE_OBJ;
  307.     for (oid = obj_child(obj), i = 1;
  308.          oid != NOTHING;
  309.          oid = obj_sibling(oid), i++) {
  310.         child.v.obj = oid;
  311.         r.v.list[i] = child;
  312.     }
  313.  
  314.     return make_var_pack(r);
  315.     }
  316. }
  317.  
  318. static package
  319. bf_max_object(Var arglist, Byte next, void *vdata, Objid progr) 
  320. { /* () */
  321.     Var r;
  322.  
  323.     r.type = TYPE_OBJ;
  324.     r.v.obj = db_size() - 1;
  325.     free_var(arglist);
  326.     return make_var_pack(r);
  327. }
  328.  
  329. static enum error 
  330. move_to_nothing(Objid oid, Byte func_pc, Objid *data)
  331. {
  332.     /* All we need to do is the exitfunc and the remove_content */
  333.     Objid     oldloc = obj_location(oid);
  334.     Var     args;
  335.     enum error    e;
  336.     
  337.     if (valid(oldloc))
  338.     remove_content(oldloc, oid);
  339.     
  340.     set_obj_location(oid, NOTHING);
  341.     
  342.     args = new_list(1);
  343.     args.v.list[1].type = TYPE_OBJ;
  344.     args.v.list[1].v.obj = oid;
  345.     
  346.     e = call_verb(oldloc, "exitfunc", args, 0);
  347.     /* e != E_TYPE */
  348.     
  349.     if (e != E_NONE)
  350.     free_var(args);
  351.     
  352.     return e;
  353. }
  354.  
  355. static package
  356. bf_recycle(Var arglist, Byte func_pc, void *vdata, Objid progr)
  357. { /* (object) */
  358.     Objid       oid;
  359.     Var         args;
  360.     enum error    e;
  361.     Objid       *data = vdata;
  362.     
  363.     switch (func_pc) {
  364.       case 1:
  365.     oid = arglist.v.list[1].v.obj;
  366.     free_var(arglist);
  367.  
  368.     if (!valid(oid)) 
  369.         return make_error_pack(E_INVARG);
  370.     
  371.     if (!is_wizard(progr)  &&  obj_owner(oid) != progr)
  372.         return make_error_pack(E_PERM);
  373.     
  374.     data = alloc_data(sizeof(*data));
  375.     *data = oid;
  376.     args = new_list(0);
  377.     e = call_verb(oid, "recycle", args, 0);
  378.     /* e != E_INVIND or E_TYPE */
  379.     
  380.     if (e == E_NONE) 
  381.         return make_call_pack(2, data);
  382.     /* else e == E_VERBNF or E_MAXREC; fall through */
  383.     free_var(args);
  384.     goto moving_contents;
  385.  
  386.       case 2:            /* moving all contents to #-1 */
  387.     free_var(arglist);
  388.     oid = *data;
  389.  
  390.       moving_contents:
  391.     if (!valid(oid)) {
  392.         free_data(data);
  393.         return no_var_pack();
  394.     }
  395.  
  396.     while (obj_contents(oid) != NOTHING) {
  397.         if (move_to_nothing(obj_contents(oid), 2, data) == E_NONE)
  398.         return make_call_pack(2, data);
  399.     }
  400.  
  401.     if (obj_location(oid) != NOTHING
  402.         &&  move_to_nothing(oid, 2, data) == E_NONE)
  403.         /* Return to same case because this :exitfunc might add new */
  404.         /* contents to OID or even move OID right back in. */
  405.         return make_call_pack(2, data);
  406.  
  407.     /* We can now be confident that OID has no contents and no location */
  408.  
  409. #ifdef MACINTOSH
  410.     /* Do the same thing for the inheritance hierarchy (much easier!) */
  411.     while (obj_child(oid) != NOTHING)
  412.         do_change_parent(obj_child(oid), obj_parent(oid));
  413. #else
  414.     /* Do the same thing for the inheritance hierarchy (much easier!) */
  415.     while (obj_child(oid) != NOTHING)
  416.         (void) do_change_parent(obj_child(oid), obj_parent(oid));
  417. #endif
  418.  
  419.     if (valid(obj_parent(oid)))
  420.         remove_child(obj_parent(oid), oid);
  421.  
  422.     /* Finish the demolition. */
  423.     destroy_object(oid);
  424.     
  425.     free_data(data);
  426.     return no_var_pack();
  427.     }
  428.     
  429.     panic("Can't happen in BF_RECYCLE");
  430.     return no_var_pack();
  431. }
  432.  
  433. static void
  434. bf_recycle_write(void *vdata)
  435. {
  436.     Objid      *data = vdata;
  437.     
  438.     db_printf("bf_recycle data: oid = %d, cont = 0\n", *data);
  439. }
  440.  
  441. static void *
  442. bf_recycle_read(FILE *f)
  443. {
  444.     Objid      *data = alloc_data(sizeof(*data));
  445.     int        junk;
  446.     
  447.     if (fscanf(f, "bf_recycle data: oid = %d, cont = %d\n", data, &junk) == 2)
  448.     return data;
  449.     else
  450.     return 0;
  451. }    
  452.  
  453. static package
  454. bf_players(Var arglist, Byte next, void *vdata, Objid progr)
  455. { /* () */
  456.     free_var(arglist);
  457.     return make_var_pack(var_ref(players_list));
  458. }
  459.  
  460. static package
  461. bf_is_player(Var arglist, Byte next, void *vdata, Objid progr)
  462. { /* (object) */
  463.     Var r;
  464.     Objid oid = arglist.v.list[1].v.obj;
  465.     
  466.     free_var(arglist);
  467.     
  468.     if (!valid(oid))
  469.     return make_error_pack(E_INVARG);
  470.     
  471.     r.type = TYPE_NUM;
  472.     r.v.num = is_player(oid);
  473.     return make_var_pack(r);
  474. }
  475.  
  476. static package
  477. bf_set_player_flag(Var arglist, Byte next, void *vdata, Objid progr) 
  478. { /* (object, yes/no) */
  479.     Var obj;
  480.     char bool;
  481.     
  482.     obj = arglist.v.list[1];
  483.     bool = is_true(arglist.v.list[2]);
  484.     
  485.     free_var(arglist);
  486.     
  487.     if (!valid(obj.v.obj))
  488.     return make_error_pack(E_INVARG);
  489.     else if (!is_wizard(progr)) 
  490.     return make_error_pack(E_PERM);
  491.     
  492.     if (bool) {
  493.     players_list = setadd(players_list, obj);
  494.     set_obj_flags(obj.v.obj, obj_flags(obj.v.obj) | (1 << FLAG_PLAYER));
  495.     } else {
  496.     boot_player(obj.v.obj);
  497.     players_list = setremove(players_list, obj);
  498.     set_obj_flags(obj.v.obj, obj_flags(obj.v.obj) & ~(1 << FLAG_PLAYER));
  499.     }
  500.     return no_var_pack();
  501. }
  502.  
  503. static package
  504. bf_move(Var arglist, Byte next, void *vdata, Objid progr)
  505. {
  506.     struct bf_move_data *data = vdata;
  507.     package        p;
  508.     
  509.     if (next == 1) {
  510.     data = alloc_data(sizeof(*data));
  511.     data->what = arglist.v.list[1].v.obj;
  512.     data->where = arglist.v.list[2].v.obj;
  513.     }
  514.     
  515.     p = do_move(arglist, next, data, progr);
  516.     free_var(arglist);
  517.     
  518.     if (p.why != BI_CALL)
  519.     free_data(data);
  520.     
  521.     return p;
  522. }
  523.  
  524. static void
  525. bf_move_write(void *vdata)
  526. {
  527.     struct bf_move_data *data = vdata;
  528.     db_printf("bf_move data: what = %d, where = %d\n",
  529.           data->what, data->where);
  530. }
  531.  
  532. static void *
  533. bf_move_read(FILE *f)
  534. {
  535.     struct bf_move_data *data = alloc_data(sizeof(struct bf_move_data));
  536.  
  537.     if (fscanf(f, "bf_move data: what = %d, where = %d\n", 
  538.            &(data->what), &(data->where)) == 2)
  539.     return data;
  540.     else
  541.     return 0;
  542. }    
  543.  
  544. void
  545. register_objects(void)
  546. { 
  547.     (void) register_function("toobj", 1, 1, bf_toobj, TYPE_ANY);
  548.     (void) register_function("typeof", 1, 1, bf_typeof, TYPE_ANY);
  549.     (void) register_function_with_read_write("create", 1, 2, bf_create,
  550.                       bf_create_read, bf_create_write,
  551.                       TYPE_OBJ, TYPE_OBJ);
  552.     (void) register_function_with_read_write("recycle", 1, 1, bf_recycle,
  553.                       bf_recycle_read, bf_recycle_write,
  554.                       TYPE_OBJ);
  555.     (void) register_function("valid", 1, 1, bf_valid, TYPE_OBJ);
  556.     (void) register_function("parent", 1, 1, bf_parent, TYPE_OBJ);
  557.     (void) register_function("children", 1, 1, bf_children, TYPE_OBJ);
  558.     (void) register_function("chparent", 2, 2, bf_chparent,
  559.                  TYPE_OBJ, TYPE_OBJ);
  560.     (void) register_function("max_object", 0, 0, bf_max_object);
  561.     (void) register_function("players", 0, 0, bf_players);
  562.     (void) register_function("is_player", 1, 1, bf_is_player, TYPE_OBJ);
  563.     (void) register_function("set_player_flag", 2, 2, bf_set_player_flag,
  564.                  TYPE_OBJ, TYPE_ANY);
  565.     (void)register_function_with_read_write("move", 2, 2, bf_move,
  566.                         bf_move_read, bf_move_write,
  567.                         TYPE_OBJ, TYPE_OBJ);
  568. }
  569.  
  570. char rcsid_objects[] = "$Id: objects.c,v 1.12 1992/10/23 23:03:47 pavel Exp $";
  571.  
  572. /* $Log: objects.c,v $
  573.  * Revision 1.12  1992/10/23  23:03:47  pavel
  574.  * Added copyright notice.
  575.  *
  576.  * Revision 1.11  1992/10/23  22:02:24  pavel
  577.  * Eliminated all uses of the useless macro NULL.
  578.  *
  579.  * Revision 1.10  1992/10/17  20:47:39  pavel
  580.  * Global rename of strdup->str_dup, strref->str_ref, vardup->var_dup, and
  581.  * varref->var_ref.
  582.  *
  583.  * Revision 1.9  1992/09/14  18:40:24  pjames
  584.  * Updated #includes.  Moved rcsid to bottom.
  585.  *
  586.  * Revision 1.8  1992/09/14  17:32:23  pjames
  587.  * Moved db_modification code to db modules.
  588.  *
  589.  * Revision 1.7  1992/09/08  22:02:11  pjames
  590.  * Renamed bf_obj.c to objects.c
  591.  *
  592.  * Revision 1.6  1992/09/04  01:24:21  pavel
  593.  * Added support for the `f' (for `fertile') bit on objects.
  594.  *
  595.  * Revision 1.5  1992/09/03  16:32:24  pjames
  596.  * Free's propdefs using new array structure.
  597.  *
  598.  * Revision 1.4  1992/08/28  16:04:12  pjames
  599.  * Changed myfree(*, M_STRING) to free_str(*).
  600.  *
  601.  * Revision 1.3  1992/08/10  17:18:58  pjames
  602.  * Updated #includes.  Move bf_pass to execute.c Updated to use new
  603.  * registration format.  Built in functions now only receive programmer,
  604.  * instead of entire Parse_Info.
  605.  *
  606.  * Revision 1.2  1992/07/20  23:52:48  pavel
  607.  * Added rcsid_<filename-root> declaration to hold the RCS ident. string.
  608.  *
  609.  * Revision 1.1  1992/07/20  23:23:12  pavel
  610.  * Initial RCS-controlled version.
  611.  */
  612.